export const hi: string = '你好啊 ts'
console.log(hi)
let a: number;
a = 5
function sum(a: number, b: number, c?: number): boolean {
    return a + b > 5 ? true : false;
}
const result = sum(3, 5)

let b: unknown
b = 'test'

if (typeof b === 'number') {
    a = b
}

// 类型断言 as 
a = b as number //第一种 as 类型

a = <number>b  // 第二种 <类型>变量

function fn(): void { //void表示返回空值
    //可以 return null | undefined 
    console.log(333)
}

function fn2(): never { //never 表示永远没有返回结果
    throw new Error('报错了')
}


let c: object

c = function () { }
c = {}

let d: { name: string, age?: number }  //?表示这个属性有也可以 没有也无所谓 是可选属性
d = { name: '么么哒' }


let e: { name: string, [propName: string]: unknown } //[propName: string]: unknown表示对象里可以有任意属性

e = { name: '皮皮倩', age: 80, gender: '男' }

// 设置函数结构类型 函数名：(形参：类型，形参：类型 ,....)=>返回值

let f: (a: boolean, b: string) => void

f = (a: boolean, b: string): void => {
    return
}
const g = f(true, '4')

let h: string[] // 定义一个里面存储为字符串的数组  第一种:类型[]
h = ['1', '2']

let j: Array<object> // 第二种方法为 Array<类型>
j = [{ a: 1 }]

// 元组  固定数组长度 tuple
let m: [string, string]
m = ['1', '2']

// enum 枚举类型
enum Status {
    success = 1,
    fail = 0
}

let n: { name: string, six: Status }

n = { name: '瓜娃子', six: Status.fail }

console.log('n', n)

//类别名

type myType = string | number
let i: myType
let w: myType

type x = {
    name: string
}
let xxx: x = {
    name: '333'
}

class sayBai {  // static表示静态属性  或者静态方法  可以不通过实例来访问 直接通过类访问
    static hua: string

}
sayBai.hua

/*
*  implements 表示当前类按照接口的结构来实现

*  extends 继承属性   
*/
interface l<T> { //定义一个类的结构 是抽象的 不能定义
    name: string;
    sayhello: (val:string)=>T
}
class User{
  
}
class pipiqian implements l<User> {
    name: string;
    constructor(name: string) {
        this.name = name
    };
    sayhello(val:string):User {
        return val
    }
}
const p = new pipiqian('皮皮倩')
p.sayhello('Wangwangwang')
p.name


//abstract 表示当前类 只能被继承 
abstract class person {
    name: string;
    age: number
    constructor(name: string, age: number) {
        this.name = name
        this.age = age
    };
    abstract say(): void
}


class child extends person {
    protected sex: string;// 默认值是public  private是私有的 只能在类的内部进行访问和修改  protected只能在当前类和子类中访问
    constructor(name: string, age: number, sex: string) {
        super(name, age)
        this.sex = sex
    }
    say() {
        console.log('喊爸爸了')
    }
}

// let obj = {}
// console.log(obj)
// let obj1 = new Object();
// console.log(obj1)
// let obj2 = new Map();
// console.log(Object.fromEntries(obj2))
// class Obj {
//     name: string;
//     constructor(name: string) {
//         this.name = name
//     }
// }
// let obj3 = new Obj('张三')
// console.log(obj3)

const jiujiu = new child('jiujiu', 1, '男')
console.log(jiujiu)
jiujiu.say()
const baobei = new child('baobei', 0, '女')
baobei.say()
console.log(baobei)


